/**
 * API 请求统一管理
 * 已核对所有API与后端接口的HTTP方法匹配性
 */
import axios from 'axios'
import router from '@/router'
import admin from './admin'

// 创建axios实例
const instance = axios.create({
  baseURL: '/api',  // 通过代理访问后端
  timeout: 10000,
  withCredentials: true,  // 允许跨域携带cookie
})

// 请求拦截器
instance.interceptors.request.use(
  config => {
    // 保存原始URL用于日志对比
    const originalUrl = config.url;
    
    // 从localStorage中获取token
    const token = localStorage.getItem('token')
    // 如果有token则添加到请求头
    if (token) {
      // 确保token格式正确并且包含用户名
      config.headers['Authorization'] = token
      
      // 添加调试日志
      console.log('请求添加Authorization:', token);
    }
    
    // 处理文件上传请求，避免设置可能包含非ISO-8859-1字符的headers
    const isFileUpload = config.headers['Content-Type'] === 'multipart/form-data';
    if (isFileUpload) {
      // 对于文件上传请求，仅保留必要的headers
      const safeHeaders = {
        'Accept': 'application/json, text/plain, */*',
      };
      
      // 保留原始数据
      const originalData = config.data;
      
      // 重设headers
      config.headers = safeHeaders;
      
      // 如果有token，添加到URL参数中而不是header
      if (token) {
        const url = new URL(config.baseURL + config.url, window.location.origin);
        url.searchParams.append('token', token);
        config.url = url.pathname + url.search;
      }
      
      // 恢复原始数据
      config.data = originalData;
    } else {
      // 非文件上传请求，移除headers中可能包含的非ISO-8859-1字符
      if (config.headers) {
        Object.keys(config.headers).forEach(key => {
          const value = config.headers[key];
          if (typeof value === 'string') {
            // 将非ASCII字符替换为空字符串
            config.headers[key] = value.replace(/[^\x20-\x7E]/g, '');
          }
        });
      }
      
      // 对于POST、PUT请求，如果数据不是FormData或URLSearchParams，则转换为表单格式
      if ((config.method === 'post' || config.method === 'put') && 
          config.data && 
          !(config.data instanceof FormData) && 
          !(config.data instanceof URLSearchParams)) {
        
        const params = new URLSearchParams();
        
        // 检查是否为普通对象
        if (config.data && typeof config.data === 'object' && !Array.isArray(config.data)) {
          // 对象转换为表单数据
          for (const key in config.data) {
            if (Object.prototype.hasOwnProperty.call(config.data, key)) {
              // 确保key和value都是字符串
              const safeKey = String(key);
              const safeValue = (config.data[key] !== null && config.data[key] !== undefined) 
                ? String(config.data[key]) 
                : '';
              
              params.append(safeKey, safeValue);
            }
          }
          
          config.data = params;
          config.headers['Content-Type'] = 'application/x-www-form-urlencoded';
        }
        // 不是普通对象，不进行转换
      }
    }
    
    // 确保URL不被意外修改
    if (config.url !== originalUrl) {
      // 如果是草稿相关操作，URL不应该被修改
      if (originalUrl.includes('/draft/') || 
         (config.data && 
          ((config.data instanceof URLSearchParams && config.data.toString().includes('isDraft=true')) ||
           (typeof config.data === 'object' && config.data.isDraft === true)))) {
        config.url = originalUrl;
        
        // 如果原始URL包含draft但当前URL不包含，说明URL被错误修改了
        if (originalUrl.includes('/draft/') && !config.url.includes('/draft/')) {
          config.url = '/article/draft/save';
        }
      }
    }
    
    // 检查数据是否包含草稿标志
    if (config.data) {
      let isDraft = false;
      
      if (config.data instanceof URLSearchParams) {
        isDraft = config.data.has('isDraft') && config.data.get('isDraft') === 'true';
      } else if (typeof config.data === 'object' && !Array.isArray(config.data)) {
        isDraft = config.data.isDraft === true;
      }
      
      // 如果是草稿请求但URL不包含draft路径，纠正URL
      if (isDraft && !config.url.includes('/draft/')) {
        config.url = '/article/draft/save';
      }
    }
    
    return config
  },
  error => {
    return Promise.reject(error)
  }
)

// 响应拦截器
instance.interceptors.response.use(
  response => {
    // 如果响应是空数据或没有响应体，返回一个成功的空对象
    if (!response.data) {
      return {
        code: 0,
        message: '操作成功',
        data: null
      };
    }
    
    const res = response.data;
    
    // 如果后端直接返回字符串或其他非对象格式
    if (typeof res !== 'object') {
      try {
        // 尝试解析为JSON
        const parsed = JSON.parse(res);
        return parsed;
      } catch (e) {
        // 如果无法解析，构造标准响应格式
        return {
          code: 0,
          message: '操作成功',
          data: res
        };
      }
    }
    
    // 如果返回的是标准格式
    if (res.code !== undefined) {
      // 如果code是0，表示操作成功
      if (res.code === 0) {
        return res;
      } else {
        // 状态码不是0，表示有错误
        // 特殊错误处理：token过期或未登录
        if (res.code === 1001) { // FAILED_UNAUTHORIZED
          // 清除本地存储
          localStorage.removeItem('token');
          localStorage.removeItem('userInfo');
          localStorage.removeItem('userRole');
          localStorage.removeItem('isLoggedIn');
          localStorage.removeItem('username');
          
          // 使用router进行重定向而不是修改window.location
          router.push('/login');
        }
        
        // 统一直接返回错误响应，而不是使用Promise.reject
        // 这样可以在业务代码中统一处理成功和失败的情况
        return res;
      }
    }
    
    // 其他情况，返回原始响应
    return {
      code: 0,
      message: '操作成功',
      data: res
    };
  },
  error => {
    // 检查是否有响应
    if (error.response) {
      // 处理401错误
      if (error.response.status === 401) {
        // 清除本地存储的登录信息
        localStorage.removeItem('token');
        localStorage.removeItem('userInfo');
        localStorage.removeItem('userRole');
        localStorage.removeItem('isLoggedIn');
        localStorage.removeItem('username');
        
        // 获取当前路径，用于登录后重定向
        const currentPath = window.location.pathname;
        
        // 对于Ajax请求，不自动跳转，而是返回错误信息
        // 让调用方决定如何处理
        if (error.config.headers['X-Requested-With'] === 'XMLHttpRequest') {
          return Promise.reject({ 
            code: 1001, 
            message: '未登录或登录已过期，请重新登录' 
          });
        }
        
        // 对于页面请求，跳转到登录页面，并携带当前路径作为redirect参数
        router.push({
          path: '/login',
          query: {
            redirect: currentPath,
            needLogin: 'true'
          }
        });
        
        return Promise.reject({ 
          code: 1001, 
          message: '未授权或登录已过期' 
        });
      }
      
      // 处理302重定向（需要登录）
      if (error.response.status === 302) {
        router.push('/login');
        return Promise.reject({ code: 1001, message: '请先登录' });
      }
      
      // 返回后端错误信息
      if (error.response.data) {
        return Promise.reject(error.response.data);
      }
    }
    
    // 检查是否为CORS错误
    const isCorsError = error.message && (
      error.message.includes('Network Error') ||
      error.message.includes('CORS') ||
      error.message.includes('blocked by CORS policy') ||
      (error.request && !error.response) // 请求已发送但没有响应，通常是CORS或网络问题
    );
    
    if (isCorsError) {
      // 对于CORS错误，返回特定的错误代码，让调用方能够区分处理
      return Promise.reject({
        code: -1000,
        message: 'CORS错误，跨域请求被阻止',
        isCorsError: true,
        originalError: error.message
      });
    }
    
    // 其他网络错误
    return Promise.reject({
      code: -1,
      message: error.message || 'Network Error',
      data: null
    });
  }
)

// API服务
export default {
  // 用户相关 - 已确认HTTP方法与后端匹配
  user: {
    login: (username, password) => {
      const params = new URLSearchParams();
      params.append('username', username);
      params.append('password', password);
      return instance.post('/user/login', params, {
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded'
        }
      });
    },
    register: (userData) => {
      const params = new URLSearchParams();
      params.append('username', userData.username);
      params.append('nickname', userData.nickname);
      params.append('password', userData.password);
      params.append('passwordRepeat', userData.passwordRepeat);
      // email是可选的，但我们前端代码中已经收集了
      if (userData.email) {
        params.append('email', userData.email);
      }
      return instance.post('/user/register', params, {
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded'
        }
      });
    },
    getInfo(userId) {
      // 如果提供了userId，则获取特定用户信息
      return instance.get('/user/info', { 
        params: userId ? { id: userId } : null 
      });
    },
    updateProfile(data) {
      // 后端接口是modifyInfo
      return instance.post('/user/modifyInfo', data)
    },
    changePassword(data) {
      // 后端接口是modifyPwd
      return instance.post('/user/modifyPwd', {
        oldPassword: data.oldPassword,
        newPassword: data.newPassword,
        passwordRepeat: data.newPassword
      })
    },
    logout() {
      return instance.get('/user/logout')
    },
    getFavorites(params) {
      // 注意：这是一个模拟实现，实际项目中应该连接到真实后端API
      // 尝试使用实际的API端点
      return instance.get('/user/favorites', { params })
        .catch(() => {
          // 如果真实API不存在或请求失败，返回模拟数据
          return {
            code: 0,
            message: '操作成功',
            data: [],
            total: 0
          };
        });
    },
    // 获取活跃用户
    getActiveUsers(limit = 5) {
      return instance.get('/user/active', { params: { limit } });
    }
  },
  
  // 文章相关
  article: {
    // 获取文章列表
    getList(params = {}) {
      // 确保传递sort等参数到后端
      return instance.get('/article/getSortedArticles', { params })
        .then(response => {
          return response
        })
        .catch(error => {
          throw error
        })
    },
    // 获取文章详情
    getDetail(id) {
      // 正确的接口是getDetails, 参数为id
      return instance.get('/article/getDetails', { params: { id } })
    },
    // 创建文章
    create(data) {
      // 检查是否是草稿，如果是草稿则应该调用saveDraft
      if (data && data.isDraft === true) {
        delete data.isDraft;
        return this.saveDraft(data);
      }
      
      // 将数据转换为表单格式
      const formData = new URLSearchParams();
      if (data.id) formData.append('id', data.id);
      if (data.boardId) formData.append('boardId', data.boardId);
      formData.append('title', data.title || '');
      formData.append('content', data.content || '');
      
      // 添加标签和摘要
      if (data.tags) formData.append('tags', data.tags);
      if (data.summary) formData.append('summary', data.summary);
      
      return instance.post('/article/create', formData, {
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded'
        }
      })
      .then(response => {
        // 确保返回的是数字类型的ID
        if (response.code === 0 && response.data !== null && response.data !== undefined) {
          // 确保返回的ID是数字
          if (typeof response.data === 'string') {
            response.data = parseInt(response.data, 10);
          }
        }
        return response;
      })
      .catch(error => {
        throw error;
      });
    },
    // 更新文章
    update(data) {
      // 将数据转换为表单格式
      const formData = new URLSearchParams();
      formData.append('id', data.id);
      formData.append('title', data.title || '');
      formData.append('content', data.content || '');
      
      // 添加板块ID支持
      if (data.boardId) {
        formData.append('boardId', data.boardId);
      }
      
      // 添加标签支持
      if (data.tags) {
        formData.append('tags', data.tags);
      }
      
      // 添加摘要支持
      if (data.summary) {
        formData.append('summary', data.summary);
      }
      
      // 添加草稿状态支持
      if (data.isDraft) {
        formData.append('isDraft', data.isDraft);
      }
      
      return instance.post('/article/modify', formData, {
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded'
        }
      });
    },
    // 删除文章
    delete(id) {
      return instance.post('/article/delete', { id })
    },
    // 获取用户发布的文章
    getUserArticles(params) {
      return instance.get('/article/getAllByUserId', { params });
    },
    // 获取排序和搜索文章列表
    getSortedArticles(params = {}) {
      return instance.get('/article/getSortedArticles', { params });
    },
    // 点赞文章
    thumbsUp(id) {
      return instance.post('/article/thumbsUp', { id })
    },
    // 取消点赞文章
    cancelThumbsUp(id) {
      return instance.post('/article/cancelThumbsUp', { id })
    },
    // 置顶/取消置顶文章（管理员功能）
    togglePin(id) {
      // 根据当前状态切换置顶状态
      return instance.post('/admin/article/pin', { 
        articleId: id,
        isPinned: 1 // 默认设置为置顶，前端会根据返回处理UI
      })
    },
    // 获取文章评论 (假设有此接口)
    getComments(articleId) {
      // 尝试使用真实的API接口
      return instance.get('/reply/getReplies', { params: { articleId } })
        .catch(() => {
          // 如果真实API不存在或请求失败，返回模拟数据
          return {
            code: 0,
            message: '操作成功',
            data: {
              items: [],
              total: 0
            }
          };
        });
    },
    // 发表评论 (假设有此接口)
    // 注意：这是一个模拟实现，实际项目中应该连接到真实后端API
    addComment(data) {
      // 尝试使用真实的API接口
      return instance.post('/reply/create', data)
        .catch(() => {
          // 如果真实API不存在或请求失败，返回模拟数据
          return {
            code: 0,
            message: '操作成功'
          };
        });
    },
    // 删除评论 (假设有此接口)
    // 注意：这是一个模拟实现，实际项目中应该连接到真实后端API
    deleteComment(id) {
      // 尝试使用真实的API接口
      return instance.post('/reply/delete', { id })
        .catch(() => {
          // 如果真实API不存在或请求失败，返回模拟数据
          return {
            code: 0,
            message: '操作成功'
          };
        });
    },
    // 上传文章封面图
    uploadImage(data) {
      return instance.post('/upload/image', data, {
        headers: {
          'Content-Type': 'multipart/form-data'
        }
      });
    },
    // 保存文章草稿
    saveDraft(data) {
      // 将数据转换为表单格式
      const formData = new URLSearchParams();
      if (data.id) formData.append('id', data.id);
      if (data.boardId) formData.append('boardId', data.boardId);
      formData.append('title', data.title || '');
      formData.append('content', data.content || '');
      
      // 添加标签和摘要
      if (data.tags) formData.append('tags', data.tags);
      if (data.summary) formData.append('summary', data.summary);
      
      return instance.post('/article/draft/save', formData, {
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded'
        },
        timeout: 30000 // 增加到30秒
      })
      .then(response => {
        // 确保返回的是数字类型的ID
        if (response.code === 0 && response.data !== null && response.data !== undefined) {
          // 确保返回的ID是数字
          if (typeof response.data === 'string') {
            const parsedId = parseInt(response.data, 10);
            if (!isNaN(parsedId)) {
              response.data = parsedId;
            }
          }
        }
        return response;
      })
      .catch(error => {
        throw error;
      });
    },
    // 获取草稿详情
    getDraftDetail(id) {
      return instance.get(`/article/draft/detail/${id}`)
    },
    // 获取用户所有草稿
    getUserDrafts() {
      return instance.get('/article/draft/list')
    },
    // 删除草稿
    deleteDraft(id) {
      return instance.post(`/article/draft/delete/${id}`)
    },
    // 发布草稿
    publishDraft(id) {
      return instance.post(`/article/draft/publish/${id}`)
        .then(response => {
          return response
        })
        .catch(error => {
          throw error
        })
    },
    // 将文章保存为草稿
    saveArticleAsDraft(data) {
      // 将数据转换为表单格式
      const formData = new URLSearchParams();
      if (data.id) formData.append('id', data.id);
      if (data.boardId) formData.append('boardId', data.boardId);
      formData.append('title', data.title || '');
      formData.append('content', data.content || '');
      
      // 添加标签和摘要
      if (data.tags) formData.append('tags', data.tags);
      if (data.summary) formData.append('summary', data.summary);
      
      return instance.post('/article/draft/saveArticleAsDraft', formData, {
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded'
        }
      });
    },
    // 获取用户草稿数量
    countUserDrafts() {
      return instance.get('/article/draft/count')
    }
  },
  
  // 板块相关
  board: {
    getTopBoards() {
      return instance.get('/board/topList')
    },
    getAllBoards() {
      // 使用公共的板块列表接口，而不是管理员路径
      return instance.get('/board/list')
    },
    getBoardInfo(id) {
      // 后端使用 POST 方法，参数名为 id
      return instance.post('/board/getById', { id: id });
    }
  },
  
  // 站点配置相关
  config: {
    getSiteConfig() {
      // 尝试直接返回默认配置，不发送请求
      // 这样可以避免 CORS 错误完全阻止应用运行
      return Promise.resolve({
        code: 0,
        message: '操作成功',
        data: {
          siteName: '内容分享创作平台',
          siteDescription: '一个交流讨论的平台',
          logoUrl: '',
          faviconUrl: '',
          footerText: '© 2023 内容分享创作平台',
          registerEnabled: true,
          commentAuditEnabled: false
        }
      });

      // 以下代码暂时不执行，等 CORS 问题解决后可以恢复
      /*
      return instance.get('/admin/config/get')
        .catch((error) => {
          // 检查是否为CORS错误或其他网络错误
          if (error && (error.isCorsError || error.code === -1000)) {
            // CORS错误，直接使用默认配置
          } else if (error && error.response && error.response.status === 404) {
            // API端点不存在
          } else {
            // 其他错误，可能是服务器错误或网络问题
          }
          
          // 返回默认站点配置
          return {
            code: 0,
            message: '操作成功',
            data: {
              siteName: '内容分享创作平台',
              siteDescription: '一个交流讨论的平台',
              logoUrl: '',
              faviconUrl: '',
              footerText: '© 2023 内容分享创作平台',
              registerEnabled: true,
              commentAuditEnabled: false
            }
          };
        });
      */
    },
    updateSiteConfig(data) {
      const params = new URLSearchParams()
      for (const key in data) {
        params.append(key, data[key])
      }
      return instance.post('/admin/config/update', params, {
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded'
        }
      })
    }
  },
  
  // 评论相关
  comment: {
    create(data) {
      return instance.post('/reply/create', data)
    },
    delete(id) {
      return instance.delete(`/reply/delete/${id}`)
    },
    report(id, data) {
      return instance.post(`/comment/report/${id}`, data)
    },
    getReportList(id) {
      return instance.get(`/comment/reports/${id}`)
    },
    ignoreReports(id) {
      return instance.put(`/comment/ignore-reports/${id}`)
    },
    getUserComments(params) {
      // 使用新添加的接口
      return instance.get('/reply/getByUserId', { params })
    },
    getUserCommentsByArticleId(articleId) {
      return instance.get('/reply/getReplies', { 
        params: { articleId }
      })
      .then(response => {
        // 确保返回成功结果，即使后端出错也显示空评论
        if (response && response.code === 0 && response.data) {
          return {
            code: 0,
            message: '获取成功',
            data: response.data,
            total: Array.isArray(response.data) ? response.data.length : 0
          };
        }
        return {
          code: 0,
          message: '获取成功',
          data: [],
          total: 0
        };
      })
      .catch(error => {
        // 如果是未授权错误（用户未登录），返回一个空的成功响应
        if (error && error.code === 1001) {
          return {
            code: 0,
            message: '获取成功',
            data: [],
            total: 0
          };
        }
        // 其他错误，继续抛出
        throw error;
      });
    }
  },
  
  // 消息相关
  message: {
    // 获取消息列表
    getList: (params) => {
      // 确保分页参数为数字
      const pageParam = {
        ...params,
        page: params.page ? Number(params.page) : 1,
        size: params.size ? Number(params.size) : 10
      };
      
      // 获取消息列表
      return instance.get('/message/getAll', { params: pageParam })
        .then(response => {
          // 构造标准响应格式
          let data = [];
          let total = 0;
          
          // 处理不同的数据结构
          if (Array.isArray(response.data)) {
            data = response.data;
            total = response.total || data.length;
          } else if (response.data && response.data.list) {
            data = response.data.list;
            total = response.data.total || data.length;
          } else if (response.data) {
            // 单个对象或其他格式
            data = Array.isArray(response.data) ? response.data : [response.data];
            total = response.total || data.length;
          }
          
          return {
            code: 0,
            success: true,
            message: response.message || '获取成功',
            data: data,
            total: total
          };
        })
        .catch(() => {
          return {
            code: -1,
            success: false,
            message: '请求失败',
            data: [],
            total: 0
          };
        });
    },
    markAsRead: (id) => {
      return instance.post('/message/markRead', { id });
    },
    markAllAsRead: () => {
      return instance.post('/message/markAllRead');
    },
    delete: (id) => {
      return instance.post('/message/delete', { id });
    },
    reply: (msgId, content) => {
      // 使用正确的接口URL
      return instance.post('/message/reply', { 
        repliedId: msgId,
        content: content,
        type: 'private'
      });
    },
    getUnreadCount: () => {
      return instance.get('/message/getUnreadCount');
    },
    // 获取消息分类计数 - 后端需要实现此接口
    getCategoryCounts() {
      return instance.get('/message/category-counts')
        .then(response => {
          if (response && (response.code === 0 || response.success)) {
            return response;
          }
          // 如果后端未实现，返回一个默认格式的响应
          return {
            code: 0,
            success: true,
            message: '获取成功',
            data: {
              all: 0,
              unread: 0,
              private: 0,
              system: 0,
              comment: 0,
              like: 0
            }
          };
        })
        .catch(() => {
          // 接口不存在或请求失败时提供默认数据
          return {
            code: 0,
            success: true,
            message: '获取成功',
            data: {
              all: 0,
              unread: 0,
              private: 0,
              system: 0,
              comment: 0,
              like: 0
            }
          };
        });
    },
    // 标记消息为已读
    markRead(params) {
      // 根据参数类型调整调用方式
      if (params && params.type) {
        // 如果按类型标记已读，这个接口可能不存在，但我们可以尝试调用
        return instance.post('/message/markReadByType', { type: params.type })
          .catch(() => {
            // 如果接口不存在，尝试退回到标记全部已读
            return instance.post('/message/markAllRead')
              .catch(() => {
                // 如果都失败，返回一个通用成功响应
                return {
                  code: 0,
                  success: true,
                  message: '操作成功',
                  data: null
                };
              });
          });
      } else if (params && params.id) {
        // 如果是单条消息标记已读
        return instance.post('/message/markRead', { id: params.id });
      } else {
        // 默认标记所有消息已读
        return instance.post('/message/markAllRead');
      }
    },
    // 发送私信
    sendMessage(data) {
      console.log('发送私信API调用，参数:', data);
      
      // 确保参数格式正确
      const params = new URLSearchParams();
      params.append('receiveUserId', data.userId);
      params.append('content', data.content);
      params.append('type', 'private');
      
      return instance.post('/message/send', params, {
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded'
        }
      });
    },
    // 回复站内信
    replyMessage(data) {
      return instance.post('/message/reply', {
        repliedId: data.messageId,
        content: data.content,
        type: data.type || 'private'
      });
    }
  },
  
  // 管理相关
  admin,
  
  // 上传相关
  upload: {
    uploadAvatar(formData) {
      return instance.post('/upload/avatar', formData, {
        headers: {
          'Content-Type': 'multipart/form-data'
        }
      })
    },
    uploadImage(formData) {
      // 使用相对路径，不要添加额外的/api前缀
      return instance.post('/upload/image', formData, {
        headers: {
          'Content-Type': 'multipart/form-data'
        }
      })
    }
  },
  
  // 公告相关
  announcement: {
    // 获取公告列表
    getList(params = {}) {
      return instance.get('/announcement/list', { params });
    },
    // 获取置顶公告
    getTopAnnouncements() {
      return instance.get('/announcement/top');
    },
    // 获取公告详情
    getDetail(id) {
      return instance.get('/announcement/detail', { params: { id } });
    },
    // 创建公告
    create(data) {
      return instance.post('/announcement/create', data);
    },
    // 更新公告
    update(data) {
      return instance.post('/announcement/update', data);
    },
    // 删除公告
    delete(id) {
      return instance.post('/announcement/delete', { id });
    }
  },
  
  // 统计相关
  stat: {
    getDashboardData() {
      return instance.get('/admin/stats')
    },
    getVisitTrend(period) {
      return instance.get(`/admin/stat/visit-trend?period=${period}`)
    },
    getDeviceDistribution() {
      return instance.get('/admin/stat/device-distribution')
    }
  }
}

// 新增独立的deleteMessage方法，方便调用
export const deleteMessage = (id) => {
  if (!id) {
    return Promise.reject({message: 'ID不能为空'});
  }
  return instance.post('/message/delete', { id })
    .then(response => {
      return response;
    })
    .catch(error => {
      return {success: false, message: error.message || '删除消息失败'};
    });
}

// 新增独立的replyMessage方法，方便调用
export const replyMessage = (messageId, content) => {
  if (!messageId || !content) {
    return Promise.reject({message: '参数不完整'});
  }
  
  return instance.post('/message/reply', {
    repliedId: messageId,
    content: content,
    type: 'private'
  })
    .then(response => {
      return response;
    })
    .catch(error => {
      return {success: false, message: error.message || '回复消息失败'};
    });
}

 